﻿using System.Collections;
using System.Reflection;
using System.Text;
using Ln.Fram.SqlSugarCore.Abstractions;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using SqlSugar;
using Volo.Abp.Auditing;
using Volo.Abp.Data;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Entities.Events;
using Volo.Abp.Guids;
using Volo.Abp.MultiTenancy;
using Volo.Abp.Users;
using Check = Volo.Abp.Check;

namespace Ln.Fram.SqlSugarCore;

public class SqlSugarDbContext : ISqlSugarDbContext
{
	#region 构造函数
	public SqlSugarDbContext(IAbpLazyServiceProvider lazyServiceProvider)
	{
		LazyServiceProvider = lazyServiceProvider;
		var connectionCreator = LazyServiceProvider.LazyGetRequiredService<ISqlSugarDbConnectionCreator>();
		connectionCreator.OnSqlSugarClientConfig = OnSqlSugarClientConfig;
		connectionCreator.EntityService = EntityService;
		connectionCreator.DataExecuting = DataExecuting;
		connectionCreator.DataExecuted = DataExecuted;
		connectionCreator.OnLogExecuting = OnLogExecuting;
		connectionCreator.OnLogExecuted = OnLogExecuted;
		SqlSugarClient = new SqlSugarClient(connectionCreator.Build(action: options =>
		{
			options.ConnectionString = GetCurrentConnectionString();
			options.DbType = GetCurrentDbType();
		}));
		//统一使用aop处理
		connectionCreator.SetDbAop(SqlSugarClient);
		//替换默认序列化器
		SqlSugarClient.CurrentConnectionConfig.ConfigureExternalServices.SerializeService = SerializeService;
	}
	#endregion

	#region 成员属性
	/// <summary>
	/// SqlSugar 客户端
	/// </summary>
	public ISqlSugarClient SqlSugarClient { get; private set; }

	private IAbpLazyServiceProvider LazyServiceProvider { get; }
	#endregion

	#region 成员变量
	/// <summary>
	/// 当前用户
	/// </summary>
	protected ICurrentUser CurrentUser => LazyServiceProvider.GetRequiredService<ICurrentUser>();

	/// <summary>
	/// 启用多租户过滤
	/// </summary>
	protected virtual bool IsMultiTenantFilterEnabled => DataFilter?.IsEnabled<IMultiTenant>() ?? false;

	/// <summary>
	/// 启用软删除过滤
	/// </summary>
	protected virtual bool IsSoftDeleteFilterEnabled => DataFilter?.IsEnabled<ISoftDelete>() ?? false;

	/// <summary>
	/// 数据过滤器
	/// </summary>
	protected IDataFilter DataFilter => LazyServiceProvider.LazyGetRequiredService<IDataFilter>();

	/*
	/// <summary>
	/// 数据配置项
	/// </summary>
	public DbConnOptions Options => LazyServiceProvider.LazyGetRequiredService<IOptions<DbConnOptions>>().Value;
	*/
	//Lance:多数据源配置
	public SqlSugarConnOptions Options =>
		LazyServiceProvider.LazyGetRequiredService<IOptions<SqlSugarConnOptions>>().Value;

	private IGuidGenerator GuidGenerator => LazyServiceProvider.LazyGetRequiredService<IGuidGenerator>();
	private ILoggerFactory Logger => LazyServiceProvider.LazyGetRequiredService<ILoggerFactory>();
	private ICurrentTenant CurrentTenant => LazyServiceProvider.LazyGetRequiredService<ICurrentTenant>();
	private ISerializeService SerializeService => LazyServiceProvider.LazyGetRequiredService<ISerializeService>();
	#endregion

	#region 成员事件
	private IEntityChangeEventHelper EntityChangeEventHelper =>
		LazyServiceProvider.LazyGetService<IEntityChangeEventHelper>(NullEntityChangeEventHelper.Instance);
	#endregion

	#region 重写方法
	/// <summary>
	/// db切换多库支持
	/// </summary>
	/// <returns></returns>
	protected virtual string GetCurrentConnectionString()
	{
		var connectionStringResolver = LazyServiceProvider.LazyGetRequiredService<IConnectionStringResolver>();
		var connectionString = connectionStringResolver.ResolveAsync().ConfigureAwait(false).GetAwaiter().GetResult();
		if (string.IsNullOrWhiteSpace(connectionString))
			Check.NotNull(Options.DefaultLine.Url, "dbUrl未配置");
		return connectionString!;
	}

	protected virtual DbType GetCurrentDbType()
	{
		if (CurrentTenant.Name is not null)
		{
			var dbTypeFromTenantName = GetDbTypeFromTenantName(CurrentTenant.Name);
			if (dbTypeFromTenantName is not null) return dbTypeFromTenantName.Value;
		}
		Check.NotNull(Options.DefaultLine.DbType, "默认DbType未配置！");
		return Options.DefaultLine.DbType!.Value;
	}

	/// <summary>
	/// 上下文对象扩展
	/// </summary>
	/// <param name="sqlSugarClient"></param>
	protected virtual void OnSqlSugarClientConfig(ISqlSugarClient sqlSugarClient)
	{
		//需自定义扩展
		if (IsSoftDeleteFilterEnabled)
		{
			sqlSugarClient.QueryFilter.AddTableFilter<ISoftDelete>(u => u.IsDeleted == false);
		}
		if (IsMultiTenantFilterEnabled)
		{
			//表达式里只能有具体值，不能运算
			var expressionCurrentTenant = CurrentTenant.Id ?? null;
			sqlSugarClient.QueryFilter.AddTableFilter<IMultiTenant>(u => u.TenantId == expressionCurrentTenant);
		}
		CustomDataFilter(sqlSugarClient);
	}

	protected virtual void CustomDataFilter(ISqlSugarClient sqlSugarClient)
	{
	}

	protected virtual void DataExecuted(object oldValue, DataAfterModel entityInfo)
	{
	}

	/// <summary>
	/// 数据执行过滤
	/// </summary>
	/// <param name="oldValue"></param>
	/// <param name="entityInfo"></param>
	protected virtual void DataExecuting(object oldValue, DataFilterModel entityInfo)
	{
		//审计日志
		switch (entityInfo.OperationType)
		{
			case DataFilterType.UpdateByObject:
				if (entityInfo.PropertyName.Equals(nameof(IAuditedObject.LastModificationTime)))
				{
					if (!DateTime.MinValue.Equals(oldValue)) entityInfo.SetValue(DateTime.Now);
				}
				if (entityInfo.PropertyName.Equals(nameof(IAuditedObject.LastModifierId)))
				{
					if (CurrentUser.Id != null) entityInfo.SetValue(CurrentUser.Id);
				}
				break;
			case DataFilterType.InsertByObject:
				if (entityInfo.PropertyName.Equals(nameof(IEntity<Guid>.Id)))
				{
					//主键为空或者为默认最小值
					if (Guid.Empty.Equals(oldValue)) entityInfo.SetValue(GuidGenerator.Create());
				}
				if (entityInfo.PropertyName.Equals(nameof(IAuditedObject.CreationTime)))
				{
					//为空或者为默认最小值
					if (DateTime.MinValue.Equals(oldValue)) entityInfo.SetValue(DateTime.Now);
				}
				if (entityInfo.PropertyName.Equals(nameof(IAuditedObject.CreatorId)))
				{
					if (CurrentUser.Id is not null) entityInfo.SetValue(CurrentUser.Id);
				}
				if (entityInfo.PropertyName.Equals(nameof(IMultiTenant.TenantId)))
				{
					if (CurrentTenant.Id is not null) entityInfo.SetValue(CurrentTenant.Id);
				}
				break;
		}
		//领域事件
		switch (entityInfo.OperationType)
		{
			case DataFilterType.InsertByObject:
				if (entityInfo.PropertyName == nameof(IEntity<object>.Id))
					EntityChangeEventHelper.PublishEntityCreatedEvent(entityInfo.EntityValue);
				break;
			case DataFilterType.UpdateByObject:
				if (entityInfo.PropertyName == nameof(IEntity<object>.Id))
				{
					//软删除，发布的是删除事件
					if (entityInfo.EntityValue is ISoftDelete softDelete)
					{
						if (softDelete.IsDeleted == true) EntityChangeEventHelper.PublishEntityDeletedEvent(entityInfo.EntityValue);
					}
					else
						EntityChangeEventHelper.PublishEntityUpdatedEvent(entityInfo.EntityValue);
				}
				break;
			case DataFilterType.DeleteByObject:
				if (entityInfo.PropertyName == nameof(IEntity<object>.Id))
				{
					//这里SqlSugar有个特殊，删除会返回批量的结果
					if (entityInfo.EntityValue is IEnumerable entityValues)
						foreach (var entityValue in entityValues) EntityChangeEventHelper.PublishEntityDeletedEvent(entityValue);
				}
				break;
		}
	}

	/// <summary>
	/// 日志
	/// </summary>
	/// <param name="sql"></param>
	/// <param name="pars"></param>
	protected virtual void OnLogExecuting(string sql, SugarParameter[] pars)
	{
		//if (!Options.EnabledSqlLog) return;
		var sb = new StringBuilder();
		sb.AppendLine();
		sb.AppendLine("==========Ln-SQL执行:==========");
		sb.AppendLine(UtilMethods.GetSqlString(DbType.SqlServer, sql, pars));
		sb.AppendLine("===============================");
		Logger.CreateLogger<SqlSugarDbContext>().LogDebug(sb.ToString());
	}

	/// <summary>
	/// 日志
	/// </summary>
	/// <param name="sql"></param>
	/// <param name="pars"></param>
	protected virtual void OnLogExecuted(string sql, SugarParameter[] pars)
	{
		//if (!Options.EnabledSqlLog) return;
		var sqlLog = $"=========Ln-SQL耗时{SqlSugarClient.Ado.SqlExecutionTime.TotalMilliseconds}毫秒=====";
		Logger.CreateLogger<SqlSugarDbContext>().LogDebug(sqlLog.ToString());
	}

	/// <summary>
	/// 实体配置
	/// </summary>
	/// <param name="property"></param>
	/// <param name="column"></param>
	protected virtual void EntityService(PropertyInfo property, EntityColumnInfo column)
	{
		if (property.Name == nameof(IHasConcurrencyStamp.ConcurrencyStamp)) //带版本号并发更新
			column.IsEnableUpdateVersionValidation = true;
		if (property.PropertyType == typeof(ExtraPropertyDictionary)) column.IsIgnore = true;
		if (property.Name == nameof(Entity<object>.Id)) column.IsPrimarykey = true;
	}
	#endregion

	#region 自身方法
	public void SetSqlSugarClient(ISqlSugarClient sqlSugarClient)
	{
		SqlSugarClient = sqlSugarClient;
	}

	private DbType? GetDbTypeFromTenantName(string name)
	{
		if (string.IsNullOrWhiteSpace(name)) return null;
		var underscoreIndex = name.LastIndexOf('_');
		if (underscoreIndex == -1 || underscoreIndex == name.Length - 1) return null;
		var enumString = name.Substring(underscoreIndex + 1);
		if (Enum.TryParse<DbType>(enumString, out DbType result))
			return result;
		return null;
	}

	public void BackupDataBase()
	{
		// Todo: 数据库备份操作，需要重写
		/* 
		var directoryName = "database_backup";
		var fileName = DateTime.Now.ToString($"yyyyMMdd_HHmmss") + $"_{SqlSugarClient.Ado.Connection.Database}";
		if (!Directory.Exists(directoryName))
			Directory.CreateDirectory(directoryName);
		switch (Options.DbType)
		{
			case DbType.MySql:
				//MySql
				SqlSugarClient.DbMaintenance.BackupDataBase(SqlSugarClient.Ado.Connection.Database,
					$"{Path.Combine(directoryName, fileName)}.sql"); //mysql 只支持.net core
				break;
			case DbType.Sqlite:
				//Sqlite
				SqlSugarClient.DbMaintenance.BackupDataBase(null, $"{fileName}.db"); //sqlite 只支持.net core
				break;
			case DbType.SqlServer:
				//SqlServer
				SqlSugarClient.DbMaintenance.BackupDataBase(SqlSugarClient.Ado.Connection.Database,
					$"{Path.Combine(directoryName, fileName)}.bak" /*服务器路径#1#); //第一个参数库名 
				break;
			default:
				throw new NotImplementedException("其他数据库备份未实现");
		}
	*/
	}
	#endregion
}